home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 23 / CU Amiga - Super CD-ROM 23 (June 1998).iso / CUCD / Graphics / STIMP_noise / source / pgmminimax / pgmminimax.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-30  |  4.9 KB  |  242 lines
  1.  
  2. /************************************************************************/
  3. #define OP_NAME      "pgmminimax"
  4. #define VERSION      "1.02"
  5. #define DATE         "30.01.98"
  6. #define AUTHOR       "Stefan Diener"
  7. /************************************************************************/
  8.  
  9. #include <stdio.h>
  10. #include <stdarg.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <sys/types.h>
  14.  
  15. #include <STIMP/pgm.c>
  16.  
  17. struct PGM_Info source, desti;
  18. static int m, n;
  19. static int edge=1;
  20. static int form=1;
  21.  
  22. unsigned char minimax(unsigned char *feld)
  23. /* bestimmt MINIMAX aller Teilsequenzen */
  24. {
  25.   unsigned char mima=255, ma;
  26.   int i, j;
  27.  
  28.   for (i=0; i<=edge; i++)   /* Zahl der Teilsequenzen */
  29.   {
  30.     ma=feld[i];
  31.  
  32.     /* MAX dieser Teilsequenz suchen */
  33.     for (j=i+1; j<=i+edge; j++)   /* Zahl der Elemente einer Teilsequenz */
  34.       if (feld[j]>ma) ma=feld[j];
  35.  
  36.     /* vorlaeufiges MINIMAX merken */
  37.     if (mima>ma) mima=ma;
  38.   }
  39.  
  40.   /* Ergebnis nach aussen uebermitteln */
  41.   return mima;
  42. }
  43.  
  44. void Do_It_plus(void)
  45. {
  46.   int i, x, y, k, l, index;
  47.   unsigned char array[9], minimaxx, minimaxy;
  48.   unsigned char *src, *dst;
  49.  
  50.   /* Zeiger auf Bilddaten holen */
  51.   src=source.Data;
  52.   dst=desti.Data;
  53.   desti.maxval=source.maxval;
  54.  
  55.   /* fuer jeden Punkt ausser Rand */
  56.   for (y=edge; y<m-edge; y++)
  57.     for (x=edge; x<n-edge; x++)
  58.     {
  59.       /* Position berechnen */
  60.       index=y*n+x;
  61.  
  62.       /* Feld fuellen in x-Richtung */
  63.       i=0;
  64.       for (k=-edge; k<=edge; k++) array[i++]=src[index+k];
  65.       minimaxx=minimax(array);
  66.  
  67.       /* Feld fuellen in y-Richtung */
  68.       i=0;
  69.       for (l=-edge; l<=edge; l++) array[i++]=src[index+l*n];
  70.       minimaxy=minimax(array);
  71.  
  72.       /* MINIMAX des Feldes bestimmen */
  73.       dst[(y-edge)*(n-2*edge)+x-edge]=(minimaxy<minimaxx) ? minimaxy : minimaxx;
  74.     }
  75. }
  76.  
  77. void Do_It_waage(void)
  78. {
  79.   int i, x, y, k, index;
  80.   unsigned char array[9];
  81.   unsigned char *src, *dst;
  82.  
  83.   /* Zeiger auf Bilddaten holen */
  84.   src=source.Data;
  85.   dst=desti.Data;
  86.   desti.maxval=source.maxval;
  87.  
  88.   /* fuer jeden Punkt ausser Rand */
  89.   for (y=0; y<m; y++)
  90.     for (x=edge; x<n-edge; x++)
  91.     {
  92.       /* Position berechnen */
  93.       index=y*n+x;
  94.       i=0;
  95.  
  96.       /* Feld fuellen in x-Richtung */
  97.       for (k=-edge; k<=edge; k++) array[i++]=src[index+k];
  98.  
  99.       /* MINIMAX des Feldes bestimmen */
  100.       dst[y*(n-2*edge)+x-edge]=minimax(array);
  101.     }
  102. }
  103.  
  104. void Do_It_senk(void)
  105. {
  106.   int i, x, y, l, index;
  107.   unsigned char array[9];
  108.   unsigned char *src, *dst;
  109.  
  110.   /* Zeiger auf Bilddaten holen */
  111.   src=source.Data;
  112.   dst=desti.Data;
  113.   desti.maxval=source.maxval;
  114.  
  115.   /* fuer jeden Punkt ausser Rand */
  116.   for (y=edge; y<m-edge; y++)
  117.     for (x=0; x<n; x++)
  118.     {
  119.       /* Position berechnen */
  120.       index=y*n+x;
  121.       i=0;
  122.  
  123.       /* Feld fuellen in y-Richtung */
  124.       for (l=-edge; l<=edge; l++) array[i++]=src[index+l*n];
  125.  
  126.       /* MINIMAX des Feldes bestimmen */
  127.       dst[(y-edge)*n+x]=minimax(array);
  128.     }
  129. }
  130.  
  131. int main(int argc,char **argv)
  132. /* main program */
  133. {
  134.   int i, edgex, edgey;
  135.  
  136.   /* say hello */
  137.   PrintOpening(argc,argv);
  138.  
  139.   /* read the parameters */
  140.   for (i=1; i<argc; i++)
  141.   {
  142.     if ((argv[i][0]=='-') && argv[i][1])
  143.     {
  144.       switch (argv[i][1])
  145.       {
  146.         case '3': edge=1;
  147.                       break;
  148.  
  149.         case '5': edge=2;
  150.                       break;
  151.  
  152.         case '7': edge=3;
  153.                       break;
  154.  
  155.         case '9': edge=4;
  156.                       break;
  157.  
  158.         case 'e': form=3;
  159.                       break;
  160.  
  161.         case 'h': form=2;
  162.                       break;
  163.  
  164.         case 'p': form=1;
  165.                       break;
  166.  
  167.         case 'v': beVerbose=FALSE;
  168.                       break;
  169.  
  170.         default: PrintMessage("Unknown parameter: %s", argv[i]);
  171.                      Hilfe();
  172.                      exit(-1);
  173.                      break;
  174.       }
  175.     }
  176.  
  177.     if (argv[i][0]=='+')
  178.     {
  179.       switch (argv[i][1])
  180.       {
  181.         case 'v': beVerbose=TRUE;
  182.                       break;
  183.  
  184.         default: PrintMessage("Unknown parameter: %s", argv[i]);
  185.                      Hilfe();
  186.                      exit(-1);
  187.                      break;
  188.       }
  189.     }
  190.   }
  191.  
  192.   /* check minimal number of arguments */
  193.   if (argc<3)
  194.   {
  195.     PrintMessage("Not enough arguments !");
  196.     Hilfe();
  197.     exit(-1);
  198.   }
  199.  
  200.   /* check number of file names */
  201.   if (FilenameCount(argc, argv)!=2)
  202.   {
  203.     PrintMessage("Wrong number of file names !");
  204.     Hilfe();
  205.     exit(-1);
  206.   }
  207.  
  208.   if (ReadPGMFile(GetFilename(1,argc,argv),&source)==0)
  209.   {
  210.     m=source.height;
  211.     n=source.width;
  212.  
  213.     /* Aussenraender festlegen */
  214.     edgex=(form==3) ? 0 : edge;
  215.     edgey=(form==2) ? 0 : edge;
  216.  
  217.     if (CreatePGMArray(m-2*edgey, n-2*edgex, &desti)==0)
  218.     {
  219.       PrintMessage("Working ...");
  220.  
  221.       /* MINIMAX-Filterung */
  222.       switch (form)
  223.       {
  224.         case 1: Do_It_plus();  break;
  225.  
  226.         case 2: Do_It_waage();  break;
  227.  
  228.         case 3: Do_It_senk();  break;
  229.       }
  230.  
  231.       WritePGMFile(GetFilename(2,argc,argv),&desti);
  232.       FreePGMArray(&desti);
  233.     }
  234.  
  235.     FreePGMArray(&source);
  236.   }
  237.  
  238.   PrintClosing();
  239.   exit(0);
  240. }
  241.  
  242.